#[doc = "Register `AUDIO_AIAO_INT` reader"]
pub struct R(crate::R<AUDIO_AIAO_INT_SPEC>);
impl core::ops::Deref for R {
    type Target = crate::R<AUDIO_AIAO_INT_SPEC>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl core::convert::From<crate::R<AUDIO_AIAO_INT_SPEC>> for R {
    fn from(reader: crate::R<AUDIO_AIAO_INT_SPEC>) -> Self {
        R(reader)
    }
}
#[doc = "TX FIFO overflow interrupt source flag (with mask).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TX_RERROR_INT_A {
    #[doc = "0: No interrupt is generated."]
    NO_INTERRUPT = 0,
    #[doc = "1: The interrupt is generated."]
    HAS_INTERRUPT = 1,
}
impl From<TX_RERROR_INT_A> for bool {
    #[inline(always)]
    fn from(variant: TX_RERROR_INT_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `tx_rerror_int` reader - TX FIFO overflow interrupt source flag (with mask)."]
pub struct TX_RERROR_INT_R(crate::FieldReader<bool, TX_RERROR_INT_A>);
impl TX_RERROR_INT_R {
    pub(crate) fn new(bits: bool) -> Self {
        TX_RERROR_INT_R(crate::FieldReader::new(bits))
    }
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> TX_RERROR_INT_A {
        match self.bits {
            false => TX_RERROR_INT_A::NO_INTERRUPT,
            true => TX_RERROR_INT_A::HAS_INTERRUPT,
        }
    }
    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
    #[inline(always)]
    pub fn is_no_interrupt(&self) -> bool {
        **self == TX_RERROR_INT_A::NO_INTERRUPT
    }
    #[doc = "Checks if the value of the field is `HAS_INTERRUPT`"]
    #[inline(always)]
    pub fn is_has_interrupt(&self) -> bool {
        **self == TX_RERROR_INT_A::HAS_INTERRUPT
    }
}
impl core::ops::Deref for TX_RERROR_INT_R {
    type Target = crate::FieldReader<bool, TX_RERROR_INT_A>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "TX FIFO overflow interrupt source flag (without mask).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TX_RERROR_INT_UNMASK_A {
    #[doc = "0: No interrupt is generated."]
    NO_INTERRUPT = 0,
    #[doc = "1: The interrupt is generated."]
    HAS_INTERRUPT = 1,
}
impl From<TX_RERROR_INT_UNMASK_A> for bool {
    #[inline(always)]
    fn from(variant: TX_RERROR_INT_UNMASK_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `tx_rerror_int_unmask` reader - TX FIFO overflow interrupt source flag (without mask)."]
pub struct TX_RERROR_INT_UNMASK_R(crate::FieldReader<bool, TX_RERROR_INT_UNMASK_A>);
impl TX_RERROR_INT_UNMASK_R {
    pub(crate) fn new(bits: bool) -> Self {
        TX_RERROR_INT_UNMASK_R(crate::FieldReader::new(bits))
    }
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> TX_RERROR_INT_UNMASK_A {
        match self.bits {
            false => TX_RERROR_INT_UNMASK_A::NO_INTERRUPT,
            true => TX_RERROR_INT_UNMASK_A::HAS_INTERRUPT,
        }
    }
    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
    #[inline(always)]
    pub fn is_no_interrupt(&self) -> bool {
        **self == TX_RERROR_INT_UNMASK_A::NO_INTERRUPT
    }
    #[doc = "Checks if the value of the field is `HAS_INTERRUPT`"]
    #[inline(always)]
    pub fn is_has_interrupt(&self) -> bool {
        **self == TX_RERROR_INT_UNMASK_A::HAS_INTERRUPT
    }
}
impl core::ops::Deref for TX_RERROR_INT_UNMASK_R {
    type Target = crate::FieldReader<bool, TX_RERROR_INT_UNMASK_A>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "TX FIFO threshold interrupt source flag (without mask).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TX_LEVEL_INT_A {
    #[doc = "0: No interrupt is generated."]
    NO_INTERRUPT = 0,
    #[doc = "1: The interrupt is generated."]
    HAS_INTERRUPT = 1,
}
impl From<TX_LEVEL_INT_A> for bool {
    #[inline(always)]
    fn from(variant: TX_LEVEL_INT_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `tx_level_int` reader - TX FIFO threshold interrupt source flag (without mask)."]
pub struct TX_LEVEL_INT_R(crate::FieldReader<bool, TX_LEVEL_INT_A>);
impl TX_LEVEL_INT_R {
    pub(crate) fn new(bits: bool) -> Self {
        TX_LEVEL_INT_R(crate::FieldReader::new(bits))
    }
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> TX_LEVEL_INT_A {
        match self.bits {
            false => TX_LEVEL_INT_A::NO_INTERRUPT,
            true => TX_LEVEL_INT_A::HAS_INTERRUPT,
        }
    }
    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
    #[inline(always)]
    pub fn is_no_interrupt(&self) -> bool {
        **self == TX_LEVEL_INT_A::NO_INTERRUPT
    }
    #[doc = "Checks if the value of the field is `HAS_INTERRUPT`"]
    #[inline(always)]
    pub fn is_has_interrupt(&self) -> bool {
        **self == TX_LEVEL_INT_A::HAS_INTERRUPT
    }
}
impl core::ops::Deref for TX_LEVEL_INT_R {
    type Target = crate::FieldReader<bool, TX_LEVEL_INT_A>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "TX FIFO threshold interrupt source flag (without mask).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TX_LEVEL_INT_UNMASK_A {
    #[doc = "0: No interrupt is generated."]
    NO_INTERRUPT = 0,
    #[doc = "1: The interrupt is generated."]
    HAS_INTERRUPT = 1,
}
impl From<TX_LEVEL_INT_UNMASK_A> for bool {
    #[inline(always)]
    fn from(variant: TX_LEVEL_INT_UNMASK_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `tx_level_int_unmask` reader - TX FIFO threshold interrupt source flag (without mask)."]
pub struct TX_LEVEL_INT_UNMASK_R(crate::FieldReader<bool, TX_LEVEL_INT_UNMASK_A>);
impl TX_LEVEL_INT_UNMASK_R {
    pub(crate) fn new(bits: bool) -> Self {
        TX_LEVEL_INT_UNMASK_R(crate::FieldReader::new(bits))
    }
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> TX_LEVEL_INT_UNMASK_A {
        match self.bits {
            false => TX_LEVEL_INT_UNMASK_A::NO_INTERRUPT,
            true => TX_LEVEL_INT_UNMASK_A::HAS_INTERRUPT,
        }
    }
    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
    #[inline(always)]
    pub fn is_no_interrupt(&self) -> bool {
        **self == TX_LEVEL_INT_UNMASK_A::NO_INTERRUPT
    }
    #[doc = "Checks if the value of the field is `HAS_INTERRUPT`"]
    #[inline(always)]
    pub fn is_has_interrupt(&self) -> bool {
        **self == TX_LEVEL_INT_UNMASK_A::HAS_INTERRUPT
    }
}
impl core::ops::Deref for TX_LEVEL_INT_UNMASK_R {
    type Target = crate::FieldReader<bool, TX_LEVEL_INT_UNMASK_A>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "TX FIFO unfull interrupt source flag (without mask).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TX_UNFULL_INT_A {
    #[doc = "0: No interrupt is generated."]
    NO_INTERRUPT = 0,
    #[doc = "1: The interrupt is generated."]
    HAS_INTERRUPT = 1,
}
impl From<TX_UNFULL_INT_A> for bool {
    #[inline(always)]
    fn from(variant: TX_UNFULL_INT_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `tx_unfull_int` reader - TX FIFO unfull interrupt source flag (without mask)."]
pub struct TX_UNFULL_INT_R(crate::FieldReader<bool, TX_UNFULL_INT_A>);
impl TX_UNFULL_INT_R {
    pub(crate) fn new(bits: bool) -> Self {
        TX_UNFULL_INT_R(crate::FieldReader::new(bits))
    }
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> TX_UNFULL_INT_A {
        match self.bits {
            false => TX_UNFULL_INT_A::NO_INTERRUPT,
            true => TX_UNFULL_INT_A::HAS_INTERRUPT,
        }
    }
    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
    #[inline(always)]
    pub fn is_no_interrupt(&self) -> bool {
        **self == TX_UNFULL_INT_A::NO_INTERRUPT
    }
    #[doc = "Checks if the value of the field is `HAS_INTERRUPT`"]
    #[inline(always)]
    pub fn is_has_interrupt(&self) -> bool {
        **self == TX_UNFULL_INT_A::HAS_INTERRUPT
    }
}
impl core::ops::Deref for TX_UNFULL_INT_R {
    type Target = crate::FieldReader<bool, TX_UNFULL_INT_A>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "TX FIFO unfull interrupt source flag (without mask).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TX_UNFULL_INT_UNMASK_A {
    #[doc = "0: No interrupt is generated."]
    NO_INTERRUPT = 0,
    #[doc = "1: The interrupt is generated."]
    HAS_INTERRUPT = 1,
}
impl From<TX_UNFULL_INT_UNMASK_A> for bool {
    #[inline(always)]
    fn from(variant: TX_UNFULL_INT_UNMASK_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `tx_unfull_int_unmask` reader - TX FIFO unfull interrupt source flag (without mask)."]
pub struct TX_UNFULL_INT_UNMASK_R(crate::FieldReader<bool, TX_UNFULL_INT_UNMASK_A>);
impl TX_UNFULL_INT_UNMASK_R {
    pub(crate) fn new(bits: bool) -> Self {
        TX_UNFULL_INT_UNMASK_R(crate::FieldReader::new(bits))
    }
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> TX_UNFULL_INT_UNMASK_A {
        match self.bits {
            false => TX_UNFULL_INT_UNMASK_A::NO_INTERRUPT,
            true => TX_UNFULL_INT_UNMASK_A::HAS_INTERRUPT,
        }
    }
    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
    #[inline(always)]
    pub fn is_no_interrupt(&self) -> bool {
        **self == TX_UNFULL_INT_UNMASK_A::NO_INTERRUPT
    }
    #[doc = "Checks if the value of the field is `HAS_INTERRUPT`"]
    #[inline(always)]
    pub fn is_has_interrupt(&self) -> bool {
        **self == TX_UNFULL_INT_UNMASK_A::HAS_INTERRUPT
    }
}
impl core::ops::Deref for TX_UNFULL_INT_UNMASK_R {
    type Target = crate::FieldReader<bool, TX_UNFULL_INT_UNMASK_A>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "RX FIFO overflow interrupt source flag (without mask).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RX_WERROR_INT_A {
    #[doc = "0: No interrupt is generated."]
    NO_INTERRUPT = 0,
    #[doc = "1: The interrupt is generated."]
    HAS_INTERRUPT = 1,
}
impl From<RX_WERROR_INT_A> for bool {
    #[inline(always)]
    fn from(variant: RX_WERROR_INT_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `rx_werror_int` reader - RX FIFO overflow interrupt source flag (without mask)."]
pub struct RX_WERROR_INT_R(crate::FieldReader<bool, RX_WERROR_INT_A>);
impl RX_WERROR_INT_R {
    pub(crate) fn new(bits: bool) -> Self {
        RX_WERROR_INT_R(crate::FieldReader::new(bits))
    }
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> RX_WERROR_INT_A {
        match self.bits {
            false => RX_WERROR_INT_A::NO_INTERRUPT,
            true => RX_WERROR_INT_A::HAS_INTERRUPT,
        }
    }
    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
    #[inline(always)]
    pub fn is_no_interrupt(&self) -> bool {
        **self == RX_WERROR_INT_A::NO_INTERRUPT
    }
    #[doc = "Checks if the value of the field is `HAS_INTERRUPT`"]
    #[inline(always)]
    pub fn is_has_interrupt(&self) -> bool {
        **self == RX_WERROR_INT_A::HAS_INTERRUPT
    }
}
impl core::ops::Deref for RX_WERROR_INT_R {
    type Target = crate::FieldReader<bool, RX_WERROR_INT_A>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "RX FIFO overflow interrupt source flag (without mask).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RX_WERROR_INT_UNMASK_A {
    #[doc = "0: No interrupt is generated."]
    NO_INTERRUPT = 0,
    #[doc = "1: The interrupt is generated."]
    HAS_INTERRUPT = 1,
}
impl From<RX_WERROR_INT_UNMASK_A> for bool {
    #[inline(always)]
    fn from(variant: RX_WERROR_INT_UNMASK_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `rx_werror_int_unmask` reader - RX FIFO overflow interrupt source flag (without mask)."]
pub struct RX_WERROR_INT_UNMASK_R(crate::FieldReader<bool, RX_WERROR_INT_UNMASK_A>);
impl RX_WERROR_INT_UNMASK_R {
    pub(crate) fn new(bits: bool) -> Self {
        RX_WERROR_INT_UNMASK_R(crate::FieldReader::new(bits))
    }
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> RX_WERROR_INT_UNMASK_A {
        match self.bits {
            false => RX_WERROR_INT_UNMASK_A::NO_INTERRUPT,
            true => RX_WERROR_INT_UNMASK_A::HAS_INTERRUPT,
        }
    }
    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
    #[inline(always)]
    pub fn is_no_interrupt(&self) -> bool {
        **self == RX_WERROR_INT_UNMASK_A::NO_INTERRUPT
    }
    #[doc = "Checks if the value of the field is `HAS_INTERRUPT`"]
    #[inline(always)]
    pub fn is_has_interrupt(&self) -> bool {
        **self == RX_WERROR_INT_UNMASK_A::HAS_INTERRUPT
    }
}
impl core::ops::Deref for RX_WERROR_INT_UNMASK_R {
    type Target = crate::FieldReader<bool, RX_WERROR_INT_UNMASK_A>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "RX FIFO threshold interrupt source flag (without mask).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RX_LEVEL_INT_A {
    #[doc = "0: No interrupt is generated."]
    NO_INTERRUPT = 0,
    #[doc = "1: The interrupt is generated."]
    HAS_INTERRUPT = 1,
}
impl From<RX_LEVEL_INT_A> for bool {
    #[inline(always)]
    fn from(variant: RX_LEVEL_INT_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `rx_level_int` reader - RX FIFO threshold interrupt source flag (without mask)."]
pub struct RX_LEVEL_INT_R(crate::FieldReader<bool, RX_LEVEL_INT_A>);
impl RX_LEVEL_INT_R {
    pub(crate) fn new(bits: bool) -> Self {
        RX_LEVEL_INT_R(crate::FieldReader::new(bits))
    }
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> RX_LEVEL_INT_A {
        match self.bits {
            false => RX_LEVEL_INT_A::NO_INTERRUPT,
            true => RX_LEVEL_INT_A::HAS_INTERRUPT,
        }
    }
    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
    #[inline(always)]
    pub fn is_no_interrupt(&self) -> bool {
        **self == RX_LEVEL_INT_A::NO_INTERRUPT
    }
    #[doc = "Checks if the value of the field is `HAS_INTERRUPT`"]
    #[inline(always)]
    pub fn is_has_interrupt(&self) -> bool {
        **self == RX_LEVEL_INT_A::HAS_INTERRUPT
    }
}
impl core::ops::Deref for RX_LEVEL_INT_R {
    type Target = crate::FieldReader<bool, RX_LEVEL_INT_A>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "RX FIFO threshold interrupt source flag (without mask).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RX_LEVEL_INT_UNMASK_A {
    #[doc = "0: No interrupt is generated."]
    NO_INTERRUPT = 0,
    #[doc = "1: The interrupt is generated."]
    HAS_INTERRUPT = 1,
}
impl From<RX_LEVEL_INT_UNMASK_A> for bool {
    #[inline(always)]
    fn from(variant: RX_LEVEL_INT_UNMASK_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `rx_level_int_unmask` reader - RX FIFO threshold interrupt source flag (without mask)."]
pub struct RX_LEVEL_INT_UNMASK_R(crate::FieldReader<bool, RX_LEVEL_INT_UNMASK_A>);
impl RX_LEVEL_INT_UNMASK_R {
    pub(crate) fn new(bits: bool) -> Self {
        RX_LEVEL_INT_UNMASK_R(crate::FieldReader::new(bits))
    }
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> RX_LEVEL_INT_UNMASK_A {
        match self.bits {
            false => RX_LEVEL_INT_UNMASK_A::NO_INTERRUPT,
            true => RX_LEVEL_INT_UNMASK_A::HAS_INTERRUPT,
        }
    }
    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
    #[inline(always)]
    pub fn is_no_interrupt(&self) -> bool {
        **self == RX_LEVEL_INT_UNMASK_A::NO_INTERRUPT
    }
    #[doc = "Checks if the value of the field is `HAS_INTERRUPT`"]
    #[inline(always)]
    pub fn is_has_interrupt(&self) -> bool {
        **self == RX_LEVEL_INT_UNMASK_A::HAS_INTERRUPT
    }
}
impl core::ops::Deref for RX_LEVEL_INT_UNMASK_R {
    type Target = crate::FieldReader<bool, RX_LEVEL_INT_UNMASK_A>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "RX FIFO non-empty interrupt source flag (without mask).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RX_UNEMPTY_INT_A {
    #[doc = "0: No interrupt is generated."]
    NO_INTERRUPT = 0,
    #[doc = "1: The interrupt is generated."]
    HAS_INTERRUPT = 1,
}
impl From<RX_UNEMPTY_INT_A> for bool {
    #[inline(always)]
    fn from(variant: RX_UNEMPTY_INT_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `rx_unempty_int` reader - RX FIFO non-empty interrupt source flag (without mask)."]
pub struct RX_UNEMPTY_INT_R(crate::FieldReader<bool, RX_UNEMPTY_INT_A>);
impl RX_UNEMPTY_INT_R {
    pub(crate) fn new(bits: bool) -> Self {
        RX_UNEMPTY_INT_R(crate::FieldReader::new(bits))
    }
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> RX_UNEMPTY_INT_A {
        match self.bits {
            false => RX_UNEMPTY_INT_A::NO_INTERRUPT,
            true => RX_UNEMPTY_INT_A::HAS_INTERRUPT,
        }
    }
    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
    #[inline(always)]
    pub fn is_no_interrupt(&self) -> bool {
        **self == RX_UNEMPTY_INT_A::NO_INTERRUPT
    }
    #[doc = "Checks if the value of the field is `HAS_INTERRUPT`"]
    #[inline(always)]
    pub fn is_has_interrupt(&self) -> bool {
        **self == RX_UNEMPTY_INT_A::HAS_INTERRUPT
    }
}
impl core::ops::Deref for RX_UNEMPTY_INT_R {
    type Target = crate::FieldReader<bool, RX_UNEMPTY_INT_A>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
#[doc = "RX FIFO non-empty interrupt source flag (without mask).\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum RX_UNEMPTY_INT_UNMASK_A {
    #[doc = "0: No interrupt is generated."]
    NO_INTERRUPT = 0,
    #[doc = "1: The interrupt is generated."]
    HAS_INTERRUPT = 1,
}
impl From<RX_UNEMPTY_INT_UNMASK_A> for bool {
    #[inline(always)]
    fn from(variant: RX_UNEMPTY_INT_UNMASK_A) -> Self {
        variant as u8 != 0
    }
}
#[doc = "Field `rx_unempty_int_unmask` reader - RX FIFO non-empty interrupt source flag (without mask)."]
pub struct RX_UNEMPTY_INT_UNMASK_R(crate::FieldReader<bool, RX_UNEMPTY_INT_UNMASK_A>);
impl RX_UNEMPTY_INT_UNMASK_R {
    pub(crate) fn new(bits: bool) -> Self {
        RX_UNEMPTY_INT_UNMASK_R(crate::FieldReader::new(bits))
    }
    #[doc = r"Get enumerated values variant"]
    #[inline(always)]
    pub fn variant(&self) -> RX_UNEMPTY_INT_UNMASK_A {
        match self.bits {
            false => RX_UNEMPTY_INT_UNMASK_A::NO_INTERRUPT,
            true => RX_UNEMPTY_INT_UNMASK_A::HAS_INTERRUPT,
        }
    }
    #[doc = "Checks if the value of the field is `NO_INTERRUPT`"]
    #[inline(always)]
    pub fn is_no_interrupt(&self) -> bool {
        **self == RX_UNEMPTY_INT_UNMASK_A::NO_INTERRUPT
    }
    #[doc = "Checks if the value of the field is `HAS_INTERRUPT`"]
    #[inline(always)]
    pub fn is_has_interrupt(&self) -> bool {
        **self == RX_UNEMPTY_INT_UNMASK_A::HAS_INTERRUPT
    }
}
impl core::ops::Deref for RX_UNEMPTY_INT_UNMASK_R {
    type Target = crate::FieldReader<bool, RX_UNEMPTY_INT_UNMASK_A>;
    #[inline(always)]
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl R {
    #[doc = "Bit 11 - TX FIFO overflow interrupt source flag (with mask)."]
    #[inline(always)]
    pub fn tx_rerror_int(&self) -> TX_RERROR_INT_R {
        TX_RERROR_INT_R::new(((self.bits >> 11) & 0x01) != 0)
    }
    #[doc = "Bit 10 - TX FIFO overflow interrupt source flag (without mask)."]
    #[inline(always)]
    pub fn tx_rerror_int_unmask(&self) -> TX_RERROR_INT_UNMASK_R {
        TX_RERROR_INT_UNMASK_R::new(((self.bits >> 10) & 0x01) != 0)
    }
    #[doc = "Bit 9 - TX FIFO threshold interrupt source flag (without mask)."]
    #[inline(always)]
    pub fn tx_level_int(&self) -> TX_LEVEL_INT_R {
        TX_LEVEL_INT_R::new(((self.bits >> 9) & 0x01) != 0)
    }
    #[doc = "Bit 8 - TX FIFO threshold interrupt source flag (without mask)."]
    #[inline(always)]
    pub fn tx_level_int_unmask(&self) -> TX_LEVEL_INT_UNMASK_R {
        TX_LEVEL_INT_UNMASK_R::new(((self.bits >> 8) & 0x01) != 0)
    }
    #[doc = "Bit 7 - TX FIFO unfull interrupt source flag (without mask)."]
    #[inline(always)]
    pub fn tx_unfull_int(&self) -> TX_UNFULL_INT_R {
        TX_UNFULL_INT_R::new(((self.bits >> 7) & 0x01) != 0)
    }
    #[doc = "Bit 6 - TX FIFO unfull interrupt source flag (without mask)."]
    #[inline(always)]
    pub fn tx_unfull_int_unmask(&self) -> TX_UNFULL_INT_UNMASK_R {
        TX_UNFULL_INT_UNMASK_R::new(((self.bits >> 6) & 0x01) != 0)
    }
    #[doc = "Bit 5 - RX FIFO overflow interrupt source flag (without mask)."]
    #[inline(always)]
    pub fn rx_werror_int(&self) -> RX_WERROR_INT_R {
        RX_WERROR_INT_R::new(((self.bits >> 5) & 0x01) != 0)
    }
    #[doc = "Bit 4 - RX FIFO overflow interrupt source flag (without mask)."]
    #[inline(always)]
    pub fn rx_werror_int_unmask(&self) -> RX_WERROR_INT_UNMASK_R {
        RX_WERROR_INT_UNMASK_R::new(((self.bits >> 4) & 0x01) != 0)
    }
    #[doc = "Bit 3 - RX FIFO threshold interrupt source flag (without mask)."]
    #[inline(always)]
    pub fn rx_level_int(&self) -> RX_LEVEL_INT_R {
        RX_LEVEL_INT_R::new(((self.bits >> 3) & 0x01) != 0)
    }
    #[doc = "Bit 2 - RX FIFO threshold interrupt source flag (without mask)."]
    #[inline(always)]
    pub fn rx_level_int_unmask(&self) -> RX_LEVEL_INT_UNMASK_R {
        RX_LEVEL_INT_UNMASK_R::new(((self.bits >> 2) & 0x01) != 0)
    }
    #[doc = "Bit 1 - RX FIFO non-empty interrupt source flag (without mask)."]
    #[inline(always)]
    pub fn rx_unempty_int(&self) -> RX_UNEMPTY_INT_R {
        RX_UNEMPTY_INT_R::new(((self.bits >> 1) & 0x01) != 0)
    }
    #[doc = "Bit 0 - RX FIFO non-empty interrupt source flag (without mask)."]
    #[inline(always)]
    pub fn rx_unempty_int_unmask(&self) -> RX_UNEMPTY_INT_UNMASK_R {
        RX_UNEMPTY_INT_UNMASK_R::new((self.bits & 0x01) != 0)
    }
}
#[doc = "AUDIO_AIAO_INT is the interrupt register.\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [audio_aiao_int](index.html) module"]
pub struct AUDIO_AIAO_INT_SPEC;
impl crate::RegisterSpec for AUDIO_AIAO_INT_SPEC {
    type Ux = u32;
}
#[doc = "`read()` method returns [audio_aiao_int::R](R) reader structure"]
impl crate::Readable for AUDIO_AIAO_INT_SPEC {
    type Reader = R;
}
#[doc = "`reset()` method sets AUDIO_AIAO_INT to value 0"]
impl crate::Resettable for AUDIO_AIAO_INT_SPEC {
    #[inline(always)]
    fn reset_value() -> Self::Ux {
        0
    }
}
